Method, program, and system for converting part of graph data to data structure as an image of homomorphism

ABSTRACT

To provide a method, program, and system for converting graph data to a data structure that enables manipulations in various applications to be reflected in the original graph data. The method uses at least one graph matching pattern to convert at least a part of graph data including nodes and edges to a data structure as an image of a homomorphism thereof. A pattern is provided which includes one representative node variable having a first constraint that at most one node in the graph data matches the representative node variable; the node is prohibited from matching a node variable in another pattern. The method includes the step of performing matching between the graph data and the pattern to obtain a matching result that does not violate constraints including the first constraint, and the step of generating a data structure corresponding to the matching result that does not violate the constraints.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority from Japanese Patent Application No. 2011113360 filed on May 20, 2011 and entitled “Method, Program and System for Converting Part of Graph Data to Data Structure as an Image of Homomorphism.”

FIELD OF THE INVENTION

The present invention relates generally to an information processing technique for converting a data structure, and more particularly to a method, program, and system for converting a part of graph data to a data structure as an image of a homomorphism thereof.

BACKGROUND ART

Data of a graph structure with nodes and edges representing connection relationships between the nodes (hereinafter, which may be simply referred to as “graph data”) is often used to express a real world model on a computer. Graph data is generally described in accordance with a standardized format such as the resource description framework (RDF), and stored in a database termed a “graph repository”. A part or whole of the graph data stored in a graph repository is called by various kinds of application programs for use. Companies in the industry have conducted research and development on software for handling such graph data.

As a background art in the field, Japanese Unexamined Patent Publication No. 2010-256978 (Patent Document 1) discloses a configuration data verification device for facilitating verification of configuration data. The device includes: a relation graph generation unit which extracts dependency relation between components constituting a system from the configuration data of the system and generates a relation graph representing the dependency relation; and a relation graph verification unit which verifies validity of the configuration data on the basis of a reference relation graph provided in advance and the generated relation graph. In the case where the reference relation graph and the generated relation graph are identical in type, the relation graph verification unit determines that the configuration data is valid; otherwise, it determines that the configuration data is invalid.

As another background art, Japanese Unexamined Patent Publication No. 2007-026210 (Patent Document 2) discloses an improved tree display program. According to the program, when a node 4 is designated as a display target by a user from a tree being developed/displayed from an actual root node 1 positioned in an uppermost layer in a tree structure, a tree structure in a similar form when viewed as a non-directed graph is formed and displayed in which the node 4 is disposed in the uppermost layer as a virtual root node. That a node 2 is a parent node of the node 4 is shown by adding an arrow icon 40, in a prescribed direction, to a leader line of the node 2. The relative positional relation between the virtual root node 4 and the actual root node 1 is shown by adding an arrow icon 42, in a prescribed direction, on the path from the virtual root node 4 to the actual root node 1.

As yet another background art, Japanese Unexamined Patent Publication No. 2003-030227 (Patent Document 3) discloses a method capable of handling data aggregates of various types unitarily and capable of dynamically changing the data aggregate and the data structure by reflecting an interaction from a user in the event of the preprocessing for the data mining. The method includes the steps of: creating, from XML data, a hierarchical unit tree as a tree structure in which attributes of the XML data are set as a leaf node and a non-leaf node, a relationship between the attributes without including an attribute value is expressed, and a redundant parent-child relationship between the nodes is optimized by merging; adding a change to the hierarchical unit tree; and converting the XML data so as to reflect the change added to the hierarchical unit tree.

As yet another background art, Japanese Patent No. 3137590 (Patent Document 4) discloses a manufacturing procedure determining system, wherein when an element process has been given, node connection means produces an initial graph. Initially-required node selection means selects required nodes, and initial graph producing means produces the initial graph, composed of nodes and oriented branches, corresponding to each element process. Dependency graph producing means deconstructs the initial graph to produce a dependency graph. Process expression tree producing means deconstructs the dependency graph so as to produce a process expression tree for expressing a manufacturing procedure which can be executed.

As yet another background art, Japanese Unexamined Patent Publication No. 2001-142937 (Patent Document 5) discloses a method for checking the correctness of scheduling of a circuit and a method for verifying a schedule of a circuit against a behavioral description of the circuit. The method for checking the correctness of scheduling of a circuit, where a schedule for the circuit is obtained from a behavioral description, includes the steps of: extracting loop invariants to determine a sufficient set of acyclic threads when loops are present in the circuit; performing symbolic simulation to extract the loop invariants; and proving equivalence of the acyclic threads. The method for verifying a schedule of a circuit against a behavioral description of the circuit includes the steps of: selecting a schedule thread of execution from the schedule where a thread may include loops; identifying a corresponding behavior thread from the behavioral description; proving unconditional equivalence of the schedule thread and the behavior thread; and repeating the above steps for all threads of execution.

As yet another background art, Japanese Unexamined Patent Publication No. 5-233298 (Patent Document 6) provides a ring isomorphism determination system capable of efficiently checking the existence of a bijective homomorphism using a computer when two rings are finite-dimensional over a field. According to this system, bases of the linear spaces are calculated for two arbitrary rings A and B, a linear map φ from the ring A to the ring B is defined, φ^(*) is defined by removing the constant term of the linear map φ, an ideal J is defined from an ideal I on the basis of the determinant (f) of the φ^(*), the reference relational expression of the rings A and B, and operation as a homomorphism of the linear map φ, and the determination of isomorphism or not is made on the basis of the Groebner basis GJ of the ideal.

As yet another background art, Japanese Unexamined Patent Publication No. 10-154976 (Patent Document 7) provides a tamper-free system which is capable of defending the system against the attack where a physical shock is applied from the outside to the internal circuit to cause the malfunction and the output from the internal circuit is observed to estimate confidential information within the system. The tamper-free system includes means for performing predetermined data conversion processing on data input from the outside to output the processed data, and has its internal circuit entirely protected from the outside by physical means so as to prevent illegal access to the internal information. The system includes means for detecting malfunction of the data conversion processing, and output regulating means for imposing a predetermined regulation on the output from the processing in the case where the malfunction is detected.

As yet another background art, Japanese Unexamined Patent Publication No. 2008-203964 (Patent Document 8) discloses a clustering technique as follows. The technique intelligibly summarizes a causal relation network by clustering a plurality of events while maintaining a correct causal relation between the events. With respect to a causal relation between a plurality of different events extracted from a natural language sentence as a document described in natural language, a cluster object selecting unit selects, as an object of clustering, an event group of events which have some of the constituent words identical to each other and also have a common cause or result event, and a causal relation storage unit stores a causal relation graph having a data structure in which only the causal relations common to all the events as the object of clustering are integrated. The complexity of the structure of the causal relation graph is digitized as a clustering score, and an event cluster evaluation unit clusters the event group selected by the cluster object selecting unit so as to minimize the clustering score.

PRIOR ART REFERENCES

-   [Patent Document 1] -   Japanese Unexamined Patent Publication No. 2010-256978 -   [Patent Document 2] -   Japanese Unexamined Patent Publication No. 2007-026210 -   [Patent Document 3] -   Japanese Unexamined Patent Publication No. 2003-030227 -   [Patent Document 4] -   Japanese Patent No. 3137590 -   [Patent Document 5] -   Japanese Unexamined Patent Publication No. 2001-142937 -   [Patent Document 6] -   Japanese Unexamined Patent Publication No. 5-233298 -   [Patent Document 7] -   Japanese Unexamined Patent Publication No. 10-154976 -   [Patent Document 8] -   Japanese Unexamined Patent Publication No. 2008-203964 -   [Patent Document 9] -   Japanese Unexamined Patent Publication No. 9-016389 -   [Patent Document 10] -   Japanese Unexamined Patent Publication No. 2010-033500 -   [Patent Document 11] -   Japanese Unexamined Patent Publication No. 2008-158759 -   [Patent Document 12] -   Japanese Unexamined Patent Publication No. 2006-185211 -   [Patent Document 13] -   Japanese Unexamined Patent Publication No. 2005-100402 -   [Patent Document 14] -   Japanese Unexamined Patent Publication No. 5-158676

SUMMARY OF THE INVENTION

When graph data stored in a graph repository is to be used in an application, the graph data may be too complicated or include unnecessary details for that application. Therefore, there is a demand, not to directly access the entire graph data, but to use a part or whole of the graph data by converting it to an object, as an image of a homomorphism thereof, that is defined by a user to meet the purposes of a particular application. In this case, it is preferable that the manipulations performed on the resultant object in various applications are properly reflected in the original graph data.

Any of the background art, however, has failed to provide such a technique of converting graph data to an object that enables manipulations performed on the object in various applications to be properly reflected in the original graph data.

In view of the foregoing, it is an object of the present invention to provide a method, program, and system for converting graph data to a data structure that enables a manipulation of an object by an application to be reflected in the original graph data.

In order to achieve the above object, the present invention provides a method for converting at least a part of graph data including nodes and edges to a data structure as an image of a homomorphism thereof by using at least one pattern for graph matching. The method includes the steps of: providing a pattern including one representative node variable, the representative node variable having a first constraint that at most one node in the graph data matches the representative node variable and the node is prohibited from matching a node variable in another pattern; performing matching between the graph data and the pattern to obtain a matching result that does not violate constraints including the first constraint; and generating a data structure corresponding to the matching result that does not violate the constraints.

Preferably, the step of performing matching includes steps of obtaining, as the matching result, information on a subset of the graph data that matches the pattern, and removing, from the matching result, information on any subset of the graph data that violates the constraints. Still preferably, the information on the subset of the graph data may be a table including an entry of correspondence between a node variable included in the pattern and the matching node in the graph data. Preferably, the step of removing information from the matching result includes a step of removing the table corresponding to the subset of the graph data that violates the constraints.

Preferably, a node matching the representative node variable may become an endpoint of an interlink with a node belonging to another pattern. Preferably, in the case where a plurality of patterns the representative node variable of which matched a same node in the graph data in the step of performing matching have an inheritance relationship with each other, a data structure corresponding to the matching result on the inheriting side is generated.

Preferably, the pattern includes at least one node variable of a second type and has a second constraint that a node in the graph data matching the second-type node variable has to uniquely correspond to the node in the graph data matching the representative node variable in the pattern, and a data structure corresponding to the matching result that violates neither the first constraint nor the second constraint is generated. Still preferably, a node matching the second-type node variable may become an endpoint of an interlink with a node belonging to another pattern.

Preferably, the step of performing matching includes a step of running a graph query corresponding to the pattern on the graph data. Preferably, the step of performing matching includes a step of performing matching of an interlink connecting nodes belonging to different patterns. Preferably, the step of performing matching includes a step of removing the matching result for any interlink that is inconsistent with the matching result for the node variable. Preferably, the step of performing matching includes a step of merging the matching result for the interlink into the matching result for the node variable.

Preferably, the step of generating a data structure includes a step of generating a data structure by instantiating a class definition of a data structure corresponding to the pattern. Preferably, the method further includes the step of passing the generated data structure to an application for presentation to a user.

While the present invention has been summarized above as a data structure converting method, the present invention may also be understood as a program, a program product, software, a software product, a system, a device, and so on. The program or software product may include, for example, a storage medium which stores the program or software, or a medium which transmits the program or software.

It should be noted that the above summary of the invention does not list all the features necessary for the present invention; any combination or sub-combination of the elements may also embody the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram illustrating, by way of example, an overview of a data processing system according to an embodiment of the present invention;

FIG. 2 is a functional block diagram of the data processing system according to the embodiment of the present invention;

FIG. 3 is a flowchart illustrating an operation of the data processing system according to the embodiment of the present invention;

FIG. 4 is a flowchart illustrating an operation of object data generation by the data processing system according to the embodiment of the present invention;

FIG. 5 is a flowchart illustrating, by way of example, an operation of normalization processing according to the embodiment of the present invention;

FIG. 6 is a flowchart illustrating an operation of object manipulation by the data processing system according to the embodiment of the present invention;

FIG. 7 is a flowchart illustrating an operation of DBT processing corresponding to object generating processing (CREATE) by the data processing system according to the embodiment of the present invention;

FIG. 8 is a flowchart illustrating an operation of DBT processing corresponding to object updating processing (UPDATE) by the data processing system according to the embodiment of the present invention;

FIG. 9 is a flowchart illustrating an operation of DBT processing corresponding to object deleting processing (DELETE) by the data processing system according to the embodiment of the present invention;

FIG. 10 is a flowchart illustrating an operation of graph data modification processing by the data processing system according to the embodiment of the present invention;

FIG. 11 shows, by way of example, a data set of kernel patterns according to the embodiment of the present invention;

FIG. 12 shows, by way of example, a data set of object definitions according to the embodiment of the present invention;

FIG. 13 shows, by way of example, graph data according to the embodiment of the present invention;

FIG. 14 shows kernel pattern graph queries written in SPARQL according to the embodiment of the present invention;

FIG. 15 shows results of queries using the kernel pattern graph queries written in SPARQL according to the embodiment of the present invention;

FIG. 16 shows, by way of example, a type (or class) assignment table for representative nodes according to the embodiment of the present invention;

FIG. 17 shows, by way of example, object data according to the embodiment of the present invention;

FIG. 18 shows, by way of example, object data generated from graph data according to the embodiment of the present invention;

FIG. 19 shows a first example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 20 shows manipulation logs for the first example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 21 shows changes of the DBTs in accordance with the first example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 22 shows graph data which reflects the first example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 23 shows a second example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 24 shows manipulation logs for the second example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 25 shows changes of the DBTs in accordance with the second example of the flow of the object manipulation according to the embodiment of the present invention;

FIG. 26 shows graph data which reflects the second example of the flow of the object manipulation according to the embodiment of the present invention; and

FIG. 27 shows, by way of example, the hardware configuration of an information processing device which is suitable for implementing the data processing system according to the embodiment of the present invention.

DETAILED DESCRIPTION

While a mode for carrying out the present invention will now be described in detail with reference to the drawings, the following embodiment is not to restrict the invention recited in the claims for patent. Further, all the combinations of the features discussed in the embodiment are not necessarily indispensable for the solving means of the invention.

Furthermore, the present invention can be implemented in many different manners, and should not be understood only from the content described in the embodiment. Throughout the description of the embodiment, the same elements are denoted by the same reference characters.

FIG. 1 is a diagram illustrating, by way of example, an overview of a data processing system according to an embodiment of the present invention. The data processing system includes a first terminal 100 operated by a first user, a second terminal 105 operated by a second user, and a server 110 provided with a graph repository for storing graph data. The terminals 100 and 105 and the server 110 are connected to each other via a network 115, so that they can communicate information in the form of electronic data with each other. The network 115 is typically the Internet or an intranet.

In the embodiment of the present invention, the terminals 100 and 105 operated by the users each have object handling software installed therein. Each of the terminals 100 and 105 of the embodiment of the present invention includes input/output devices which are operated by a user and provide the user with information. The input/output devices include a keyboard and a mouse as the input devices, and a display device as the output device.

In the embodiment of the present invention, a user uses a keyboard, a mouse, or other input devices to operate an application program with a window-based graphical user interface that visually presents information about the progress of work and others on the display device of the terminal 100 or 105.

Each user can request from the server 110, via the network 115, graph data to be manipulated using an application program running on the terminal 100 or 105 operated by the user. The server 110 then returns, as the requested graph data, a subset (a part) of the graph data stored in the graph repository, via the network 115. It is assumed in the embodiment of the present invention that the terminals have application programs introduced therein, the programs being common in that they manipulate the graph data stored in the graph repository but different in their purposes.

In the embodiment of the present invention, with regard to the graph data received from the graph repository, a distinction is made between: a portion that can be converted to a data structure as an image of a homomorphism, and a portion other than that portion. In the embodiment of the present invention, regarding the former portion, each terminal converts at least a part of the graph data received from the graph repository to an image of a homomorphism thereof, to thereby generate object data. Here, “homomorphic” is a concept that expresses the similarity between structures. When one structure is an image of a homomorphism of another structure, a one-to-one correspondence can be established between a manipulation of the former and a manipulation of the latter. For this characteristic, a homomorphism is often expressed as “structure-preserving”, “compatible with the structure”, and so on.

For converting graph data to object data, a subset of the graph data that matches a kind of graph matching pattern (hereinafter, which may be referred to as a “kernel pattern”) defined by a user in advance is instantiated in accordance with an object class definition (hereinafter, which may be simply referred to as an “object definition”) defined by the user in advance, to thereby generate object data suitable for the purposes of an application program used by the user.

Then, in the embodiment of the present invention, the user manipulates the object data in the application program installed in the terminal. In the embodiment of the present invention, the manipulation performed on the object data is reflected in the original graph data stored in the graph repository of the server 110, by taking advantage of the above-described homomorphic characteristic of the object data. The embodiment of the present invention ensures that a manipulation performed on an object is reflected in graph data properly so that the object which has been manipulated is identical to an object which is obtained by mapping from the graph data that has reflected the manipulation.

FIG. 2 is a functional block diagram of the data processing system including the user terminal 100 and the server 110 according to the embodiment of the present invention. The elements illustrated in the functional block diagram in FIG. 2 can be implemented in an information processing device having the hardware configuration illustrated, for example, in FIG. 27. To this end, computer programs including an operating system and object handling software, stored in a hard disk drive 13 and so on, are loaded to a main memory 4 to cause a CPU 1 to read the programs, thereby causing hardware resources and software to cooperate together.

The server 110 of the embodiment of the present invention includes a graph repository 275. The graph repository 275 of the embodiment of the present invention has the function of storing graph data. The graph data of the embodiment of the present invention includes nodes and directed or non-directed edges that represent connection relationships between the nodes, and an attribute value can be set for each of the nodes and edges. It is assumed in the embodiment of the present invention that the graph data is described in accordance with the resource description framework (RDF) format standardized as World Wide Web Consortium (W3C) recommendation.

The graph repository 275 also has the function of receiving, from a repository access unit 205 in the user terminal 100, a query written in SPARQL Protocol and RDF Query Language (SPARQL) standardized as W3C recommendation, and returning, to the repository access unit 205, a whole or part of the graph data that matches the conditions described in the query. An example of the returned graph data will be described later in detail with reference to FIG. 13 etc. The graph repository 275 for storing such graph data may be implemented as appropriate by those skilled in the art who read this specification, and therefore, no further detailed description thereof will be provided here.

The terminal 100 according to the embodiment of the present invention includes: the repository access unit 205, a pattern matching unit 210, a normalization unit 215, an object data generating unit 220, an object definition storage unit 225, a kernel pattern storage unit 230, a data binding table (DBT) storage unit 235, an object data storage unit 240, an object data manipulation unit 245, a graph data modification unit 250, a manipulation log storage unit 255, an application unit 260, and an input/output unit 265.

The repository access unit 205 of the embodiment of the present invention has the function of generating a query for querying the graph data stored in the graph repository 275 in the server 110, in accordance with an instruction that is issued by the application unit 260 and received via the graph data modification unit 250, which will be described later. The repository access unit 205 is able to transmit the generated query to the graph repository 275 via the network 115, and receive therefrom the graph data found as a result of the query.

It is assumed in the embodiment of the present invention that the repository access unit 205 has the function of accessing the graph data stored in the graph repository so as to at least query and modify the graph data. In the embodiment of the present invention, the query for accessing the graph repository is implemented as one written in SPARQL, although it is of course possible to adopt another arbitrary graph data query language. The repository access unit 205 of the embodiment of the present invention passes the graph data obtained from the graph repository 275 as a result of querying the graph data, to the pattern matching unit 210.

The pattern matching unit 210 of the embodiment of the present invention performs matching between the graph data passed from the repository access unit 205 and the kernel pattern stored in the kernel pattern storage unit 230. Examples of the kernel patterns will be described later in detail with reference to FIG. 11. For matching, a query that is written in SPARQL, prepared for each kernel pattern or generated on the basis of the kernel pattern, is run against the target graph data. Examples of the queries corresponding to the kernel patterns will be described later in detail with reference to FIG. 14. Further, the pattern matching unit 210 uses the results of the queries for the respective kernel patterns to create initial data binding tables (DBTs), and stores them in the data binding table (DBT) storage unit 235. Examples of the initial DBTs will be described later in detail with reference to FIG. 15.

The normalization unit 215 of the embodiment of the present invention processes the initial DBTs, which have been generated by the pattern matching unit 210 and stored in the DBT storage unit 235, such that the object data that is generated later by referring to the DBTs becomes an image of a homomorphism of the graph data. Herein, the processing performed on the DBTs is called “normalization”, which will be described later in detail with reference to FIG. 5.

The object data generating unit 220 of the embodiment of the present invention refers to DBTs stored in the DBT storage unit 235 and object definitions stored in the object definition storage unit 225, to convert the graph data obtained by the repository access unit 205 to object data. The graph data is converted to a format suitable for the purposes of the application program used by a user, and the generated object data is stored in the object data storage unit 240.

The object definition storage unit 225 of the embodiment of the present invention stores object class definitions (i.e. object definitions) defined by a user. The object definitions are referred to by the object data generating unit 220 for conversion of the graph data to the object data. Examples of the object definitions will be described later in detail with reference to FIG. 12.

The pattern storage unit 230 of the embodiment of the present invention stores kernel patterns for use in matching by the pattern matching unit 210. The data binding table (DBT) storage unit 235 stores DBTs generated by the pattern matching unit 210. As described previously, the DBTs stored in the DBT storage unit 235 are processed by the normalization unit 215, and referred to by the object data generating unit 220.

The object data storage unit 240 of the embodiment of the present invention stores object data that the object data generating unit 220 generates by converting the graph data. The object data stored in the object data storage unit 240 have been generated by instantiating the object definitions defined by users, and thus, each piece of object data has the data structure suitable for the purposes of the application program operated by the corresponding user. The object data stored in the object data storage unit 240 may be manipulated directly by the application unit 260 or via the object data manipulation unit 245.

The graph data modification unit 250 of the embodiment of the present invention instructs the repository access unit 205 to query or modify the graph data stored in the graph repository 275, on the basis of the user's operation of the application program in the application unit 260, or on the basis of the manipulation log of the application program in the application unit 260 that is stored in the manipulation log storage unit 255.

The manipulation log storage unit 255 of the embodiment of the present invention stores a manipulation log of the application in the application unit 260. The application unit 260 runs the application operated by the user. The input/output unit 265 passes an operation received from a user to the application unit 260, and also provides a user with, for example, a display of the object data received from the application unit 260.

FIG. 3 is a flowchart 300 illustrating an operation of the data processing system according to the embodiment of the present invention. The process starts at step 305. In step 310, a kernel pattern is defined by a user. The kernel pattern is a kind of graph matching pattern that is referred to in matching with graph data. It is assumed in the embodiment of the present invention that the definition of the kernel pattern is given by a user by interactively operating an application program having the kernel pattern defining function, or is prepared by the user in advance.

FIG. 11 shows, by way of example, a data set of kernel patterns in the embodiment of the present invention. In this example, four kernel patterns 1105, 1110, 1115, and 1120 have been defined. In the embodiment of the present invention, these kernel patterns are identified with labels α, β, γ, and δ respectively attached thereto. Each kernel pattern includes a plurality of nodes and an edge connecting the nodes to each other. The edges used in the embodiment of the present invention are directed edges. There may be an edge between nodes belonging to different kernel patterns. Such an edge between the elements belonging to the different kernel patterns is herein called an “interlink”. For example, in the example shown in FIG. 11, an interlink 1125 connects an element “$A” in the kernel pattern α with an element “$B” in the kernel pattern β. An attribute value can be set for each of the nodes and the edges.

In a kernel pattern, some of node variables have a constraint condition described therein. The constraint condition is used for removing a part of the kernel pattern matching results (more specifically, initial DBTs), which will be described later in detail. In the embodiment of the present invention, there are two constraint conditions as follows.

The first constraint condition is set to only one kind of node variable in each kernel pattern. The node variable in a kernel pattern to which the first constraint condition has been set may be called a “representative node variable”, and the node matching the representative node variable may be called a “representative node”. The first constraint condition is that “there is at most one node in graph data that matches the representative node variable and this node is prohibited from matching a node variable in another kernel pattern (except for the case where the kernel pattern has an inheritance relationship with the other kernel pattern)”. Further, in the embodiment of the present invention, the node matching the representative node variable may become an endpoint of an interlink with a node belonging to another kernel pattern. In the embodiment of the present invention, a node variable in a kernel pattern is set as a representative node variable by attaching a prefix “$” to the name of that node variable.

The second constraint condition may be set to an arbitrary node variable in a kernel pattern, although a kernel pattern does not necessarily have to include a node to which the second constraint condition is set. The node variable in a kernel pattern to which the second constraint condition has been set may be called a “unique node variable”. The second constraint condition is that “the node in the graph data that matches the unique node variable to which the second constraint condition has been set has to ‘uniquely correspond’ to the node in the graph data that matches the representative node variable in the kernel pattern”. In the embodiment of the present invention, the node matching the unique node variable may become an endpoint of an interlink with a node belonging to another kernel pattern. In the embodiment of the present invention, a node variable in a kernel pattern is set as a unique node variable by attaching a prefix “#” to the name of that node variable.

The nodes in graph data that match the above-described representative node variable and unique node variable belong to the portion in the graph data that can be converted to a data structure as an image of the homomorphism. The first and second constraint conditions described above are used to enable the conversion of the graph data to the data structure as an image of the homomorphism.

Further, in the embodiment of the present invention, a kernel pattern may include, besides the representative node variable and unique node variable, a direct-designated node which is a node in graph data directly designated by its identifier such as a URL, a literal node to which a “value” itself is set, and a general node variable which is a node variable that matches a node without constraints. The direct-designated node may be set by directly designating the identifier of the node in the graph data as the name of the node. The literal node may be set by double-quoting the name of the node for use as a “value”. The general node variable may be set by attaching a prefix “?” in front of the name of the node variable. In the embodiment of the present invention, a literal node is to be connected to a single node via an edge.

In this manner, in the embodiment of the present invention, regarding the graph data received from the graph repository, a distinction is made between: a portion that can be converted to a data structure as an image of the homomorphism, and a portion other than that portion.

Next, the process proceeds to step 315, where an object definition is set by a user operating a terminal. In the embodiment of the present invention, the object definition is set by a user who interactively operates an application program having the object defining function, or is prepared by the user in advance. In the embodiment of the present invention, the object definition defines a class that is to be referred to when converting a subset of the graph data that matches a kernel pattern to object data. More specifically, the object definition expresses a structure of an object, and a subset of the graph data matching the kernel pattern is converted into the object data by instantiating the corresponding object definition.

FIG. 12 shows, by way of example, a set of object definitions in the embodiment of the present invention. The set of the object definitions includes object definitions 1205, 1210, 1215, and 1220 corresponding to kernel patterns. These object definitions correspond respectively to the kernel patterns 1105, 1110, 1115, and 1120 shown in FIG. 11. In this example, the set also includes an object definition 1225 corresponding to an interlink. This object definition corresponds to the interlink 1125 shown in FIG. 11.

Specifically, the object definition 1205 defines that: the class has a name “Member”, it is instantiated when it matches the kernel pattern α, and it has an attribute “name”, the value of which is a string of characters (String) that is given to the node matching the node variable “#N1” in the kernel pattern. The object definition 1210 defines that: it has a name “Group”, it is instantiated when it matches the kernel pattern β, and it has an attribute “budget”, the value of which is an integer (Int) that is given to the node matching the node variable “#J” in the kernel pattern. It is noted that an edge 1235 for showing an inheritance relationship shows that the object definition 1210 defines the class that has inherited from the object definition 1205. There exists a relation 1225 named “members” between the object definitions 1210 and 1205, which relation corresponds to the interlink 1125. A symbol “*” 1230 attached to the relation 1225 is for indicating the multiplicity allowable for the relation (i.e., up to what number of relations can be formed), “*” meaning that there is no limit for the multiplicity.

The object definition 1215 defines that: it has a name “C”, it is instantiated when it matches the kernel pattern γ, and it has an attribute “x”, the value of which is a string of characters (String) that is given to the node matching the node variable “#X” in the kernel pattern. The object definition 1220 defines that: it has a name “D”, it is instantiated when it matches the kernel pattern δ, and it has an attribute “y”, the value of which is a string of characters (String) that is given to the node matching the node variable “#Y” in the kernel pattern. The way of using these object definitions for generating object data will be described later in detail.

The process then proceeds to step 320, where the user operates the application program, from the application unit 260 on the data processing system via the graph data modification unit 250 and the repository access unit 205, to query the graph repository 275 for the graph data to be processed. Specifically, a graph data query operation on the application program is detected and interpreted to generate a query written in SPARQL, which is then transmitted to the graph repository 275 for querying the graph data.

Next, in step 325, in order to make the graph data obtained by the repository access unit 205 into a form suitable for the purposes of the application program operated by the user, the kernel pattern stored in the kernel pattern storage unit 230 and the object definition stored in the object definition storage unit 225 are used to convert the graph data to object data. As described previously, the converted and generated object data is stored in the object data storage unit 240. The conversion to the object data will be described later in detail with reference to FIGS. 4 and 5.

The process then proceeds to step 330, where the object data obtained in step 325 and stored in the object data storage unit 240 is manipulated. In the embodiment of the present invention, the manipulation performed on the object data is reflected in the graph data stored in the graph repository 275 by taking advantage of the homomorphic characteristic of the object data. The processing will be described later in detail with reference to FIGS. 6, 7, 8, 9, and 10.

Next, in step 335, it is determined whether the manipulation on the object data as the processing target has been completed. If it is determined in step 335 that the manipulation on the object data as the processing target has not been completed, the process follows the NO arrow to return to step 330, where the manipulation on the object data is continued. If it is determined in step 335 that the manipulation on the object data as the processing target has been completed, the process follows the YES arrow to proceed to step 340.

In step 340, it is determined whether to perform a manipulation on other graph data. If it is determined in step 340 to perform the manipulation on the other graph data, the process follows the YES arrow to return to step 320, where the part corresponding to that other graph data is read out of the graph repository 275, and thereafter, similar processing is repeated. If it is determined in step 340 that no manipulation will be performed on other graph data, the process follows the NO arrow to proceed to step 345, where the process is terminated.

An example of the processing of converting graph data to object data, performed in step 325 in FIG. 3, will now be described in more detail with reference to a flowchart 325 in FIG. 4. FIG. 4 shows the flowchart 325 illustrating an object data generating operation by the data processing system according to the embodiment of the present invention. The process starts at step 405. In step 410, a query written in SPARQL is used to query the graph repository 275 for graph data. FIG. 13 shows graph data 1300 that is read out and returned from the graph repository in the embodiment of the present invention. It is assumed in the embodiment of the present invention that the graph data 1300, shown by way of example, is stored in the graph repository, and is read out as the processing target, using a query written in SPARQL, so as to be converted to object data.

The process then proceeds to step 415, where the graph data 1300 obtained in step 410 is subjected to pattern matching with a kernel pattern stored in the kernel pattern storage unit 230. In the embodiment of the present invention, the pattern matching is carried out, on the terminal operated by the user, by running a query written in SPARQL, prepared for each kernel pattern, on the graph data as the processing target.

FIG. 14 shows a set 1400 of graph queries, written in SPARQL, prepared for the respective kernel patterns in the embodiment of the present invention. The graph query set 1400 includes queries 1405, 1410, 1415, 1420, and 1425, which correspond respectively to the kernel patterns 1105, 1110, 1115, 1120, and the interlink 1125, shown in FIG. 11. These queries are each run on the graph data obtained in step 410, so as to obtain information about one or more subsets of the graph data 1300 that match the corresponding kernel pattern.

The process then proceeds to step 420. In step 420, for each of the subsets of the graph data 1300 matching the kernel pattern, obtained in step 415, data in a table structure called a “data binding table (DBT)” is formed as the information about the subset. Each DBT includes an entry indicating correspondence between a node included in the corresponding kernel pattern and the matching node in the graph data.

FIG. 15 shows, by way of example, initial DBTs formed as a result of queries using the graph queries, written in SPARQL, for the respective kernel patterns according to the embodiment of the present invention. In the embodiment of the present invention, five subsets of the graph data succeeded in matching with the kernel pattern α (tables 1505, 1510, 1515, 1520, 1525), one subset succeeded in matching with the kernel pattern β (table 1530), and one subset succeeded in matching with the kernel pattern γ (table 1535). With the kernel pattern δ, no subset of the graph data succeeded in matching, so that no DBT has been formed. With the interlink “members”, two edges succeeded in matching (tables 1540, 1545).

The process then proceeds to step 425, where normalization is carried out. An example of the DBT normalization processing in step 425 in FIG. 4 will now be described in more detail with reference to a flowchart 425 in FIG. 5. The process starts at step 505. In step 510, the initial DBTs obtained in step 420 are scanned to specify any node in the graph data that matches the representative node (having the prefix “$” attached thereto in the kernel pattern) in more than one DBT. In the embodiment of the present invention, the node b1 (that matches the representative nodes in the DBTs 1510 and 1530) and the node u1 (that matches the representative nodes in the DBTs 1505 and 1535) are specified.

Next, in step 515, for any DBT including no node specified in step 510, i.e. for any DBT having a node in the graph data that matches the representative node in that DBT and does not match any of the representative nodes in the other DBTs, the corresponding object definition is assigned to the representative node. As a result, the object definition 1205 (name: “Member”) is assigned to each of the representative nodes (i.e. a1, a2, and a3) in the DBTs 1515, 1520, and 1525.

The process then proceeds to step 520. In step 520, for the DBTs including the same node specified in step 510, if there is an inheritance relationship between the object definitions corresponding to the respective DBTs, then the DBT corresponding to the object definition on the inherited side is removed, and the object definition is assigned to the representative node in the DBT corresponding to the object definition on the inheriting side. In the embodiment of the present invention, for the DBTs 1510 and 1530, the object definitions 1205 and 1210 corresponding respectively thereto have the inheritance relationship. Therefore, the DBT 1510 which is on the inherited side is removed, while the DBT 1530 which is on the inheriting side is left, and the corresponding object definition 1210 (name: “Group”) is assigned to the representative node (i.e. b1).

Next, in step 525, for the DBTs including the same node specified in step 510, if there is no inheritance relationship between the object definitions corresponding to the respective DBTs, then those DBTs are all removed. In the embodiment of the present invention, the DBTs 1505 and 1535 are removed.

Through the above-described steps 510 to 525, removal of DBTs using the first constraint condition and assignment of the object definitions to the representative nodes are carried out. As a result, in the embodiment of the present invention, the DBTs 1505, 1510, and 1535 are removed, while the DBTs 1515, 1520, 1525, 1530, 1540, and 1545 are left in the DBT storage unit 235. It is noted that, in the embodiment of the present invention, the removal of the DBTs and assignment of the object definitions described above are carried out by generating an object definition assignment table 1600 shown in FIG. 16 and processing in accordance therewith.

The process then proceeds to step 530, where removal of DBTs using the second constraint condition in the kernel pattern described above is carried out. In the embodiment of the present invention, as for the unique node “#N1” in the kernel pattern 1105 to which the prefix “#” representing the second constraint condition has been attached, the node “n1” corresponds to “#N1” in both of the DBTs 1515 and 1520. “#N1”, which is the unique node, has to uniquely correspond to a node that matches the representative node “$A” in the kernel pattern 1105. Thus, the DBTs 1515 and 1520 are removed. As a result, the DBTs 1525, 1530, 1540, and 1545 are left in the DBT storage unit 235.

Next, in step 535, removal of DBTs corresponding to interlinks is carried out. Specifically, the DBTs remaining in the DBT storage unit 235 as a result of execution of the DBT normalization processing corresponding to the kernel patterns up to then (steps 505 through 530) are referred to, and any DBT corresponding to the interlink the content of which is inconsistent with those of the DBTs left in the DBT storage unit 235 is removed. In the embodiment of the present invention, the DBT 1540 which has the content inconsistent with those of the DBTs 1525 and 1530 is removed. As a result, the DBTs 1525, 1530, and 1545 are left in the DBT storage unit 235.

The process then proceeds to step 540, where it is determined whether the multiplicity of each interlink satisfies the allowable multiplicity described in the object definition. In step 540, the processing in the case where it does not satisfy the allowable multiplicity is performed as well. The processing may be performed for example in the following manner. The user may be alerted and caused to select the interlink to be instantiated, or the process may be terminated at that point. Those skilled in the art will be able to perform the processing as appropriate, and therefore, a detailed description thereof will not be provided here.

Next, in step 545, the content of the DBT corresponding to the interlink is reflected in the DBT corresponding to the object on the referring side of the interlink. More specifically, an entry including correspondence between the name of that interlink and the name of the referred-to node is added to the DBT corresponding to the referring object. In the embodiment of the present invention, the content of the DBT 1545 is added to the DBT 1530. The process then proceeds to step 550, where the process is terminated. The contents of the DBTs that have undergone the normalization processing in the embodiment of the present invention are shown in FIG. 17.

Returning to FIG. 4, in step 430, by referring to the DBTs normalized in step 425 and stored in the DBT storage unit 235 and the object definitions stored in the object definition storage unit 225, the graph data is converted to object data, or, the object definitions are instantiated to generate object data, and the generated object data is stored in the object data storage unit 240. FIG. 18 shows an example of the object data generated in the embodiment of the present invention. The process then proceeds to step 435, where the object data is transmitted to the application program in the application unit 260 and visually presented to the user via the input/output unit 265. The process is then terminated in step 440.

Next, with reference to a flowchart 330 in FIG. 6, an example of the object data manipulating processing and the accompanying processing of reflecting the result in the graph data stored in the graph repository, performed in step 330 in FIG. 3, will be described in more detail. FIG. 6 shows the flowchart illustrating an operation of object manipulation by the data processing system according to the embodiment of the present invention. The process starts at step 605. In step 610, the manipulation log storage unit 255 receives a log of object data manipulations performed via the application program by the user (herein, this log is simply referred to as the “manipulation log”) from the application unit 260, and stores the received log.

The process proceeds to step 615, where one manipulation is read from the manipulation log stored in the manipulation log storage unit 255 in step 610. The process then proceeds to step 620, where it is determined to which one of object generating manipulation (CREATE), object updating manipulation (UPDATE), and object deleting manipulation (DELETE) the read manipulation corresponds. In the embodiment of the present invention, the object generating manipulation (CREATE) includes addition of a new object. The object updating manipulation (UPDATE) includes a change of the attribute value of the existing object, and addition or deletion of the relation between the objects. The object deleting manipulation (DELETE) includes deletion of the existing object.

If it is determined in step 620 that the manipulation read in step 615 is the object generating manipulation (CREATE), the process follows the arrow labeled “CREATE” to proceed to step 625, where DBT processing corresponding to the CREATE manipulation is performed on the DBT corresponding to the object that is a target of the manipulation read in step 615. The process then proceeds to step 640. The DBT processing corresponding to the CREATE manipulation will be described later in detail with reference to a flowchart in FIG. 7.

If it is determined in step 620 that the manipulation read in step 615 is the object updating manipulation (UPDATE), the process follows the arrow labeled “UPDATE” to proceed to step 630, where DBT processing corresponding to the UPDATE manipulation is performed on the DBT corresponding to the object as a target of the manipulation read in step 615. The process then proceeds to step 640. The DBT processing corresponding to the UPDATE manipulation will be described later in detail with reference to a flowchart in FIG. 8.

If it is determined in step 620 that the manipulation read in step 615 is the object deleting manipulation (DELETE), the process follows the arrow labeled “DELETE” to proceed to step 635, where DBT processing corresponding to the DELETE manipulation is performed on the DBT corresponding to the object as a target of the manipulation read in step 615. The process then proceeds to step 640. The DBT processing corresponding to the DELETE manipulation will be described later in detail with reference to a flowchart in FIG. 9.

In step 640, it is determined whether the entries in the DBT corresponding to the object as the target of the manipulation read in step 615 are all filled. If it is determined in step 640 that one or more entries in the DBT have not been filled, the process follows the NO arrow to proceed to step 650.

If it is determined in step 640 that the entries in the DBT are all filled, the process proceeds to step 645, where the DBT is used for modification of the graph data in the graph repository 275. The graph data modification processing will be described later in detail with reference to a flowchart in FIG. 10.

The process then proceeds to step 650, where it is determined whether the manipulation log includes a manipulation yet to be read. If it is determined in step 650 that there is a remaining manipulation, the process follows the YES arrow to return to step 615, and the similar processing is repeated for the next manipulation in the manipulation log. If it is determined in step 650 that there is no remaining manipulation, the process follows the NO arrow to proceed to step 655, where the process is terminated.

Next, with reference to a flowchart 625 in FIG. 7, an example of the DBT processing corresponding to the object generating manipulation (CREATE) in the object data, performed in step 625 in FIG. 6, will be described in more detail. FIG. 7 shows the flowchart illustrating an operation of the DBT processing corresponding to the object generating manipulation (CREATE), performed by the data processing system of the embodiment of the present invention. The process starts at step 705. In step 710, a kernel pattern corresponding to the object as a target of the generating manipulation (CREATE) read in step 615 is specified.

Then, in step 715, an identifier for a node that matches the representative node in the kernel pattern corresponding to the target object is determined. Next, in step 720, a DBT corresponding to the kernel pattern is newly created. Then, in step 725, an entry indicating the representative node in the kernel pattern and a node in the graph data that matches the representative node (which is identified by the identifier generated in step 715) is added to the newly created DBT.

The process then proceeds to step 730, where a query in SPARQL for finding a shared node is generated from the kernel pattern. The shared node refers to a node in graph data that is related to a certain object and that can also be related to another object. That is, the shared node belongs to a portion in the graph data that cannot be converted to a data structure as an image of the homomorphism. In the embodiment of the present invention, a node that matches a pattern consisting only of a combination of general node variable, direct-designated node, and/or literal node may be the shared node.

It is assumed in the embodiment of the present invention that the graph repository 275 stores graph data according to the RDF format as a set of combinations each including two nodes and an edge connecting the nodes. Thus, a query for finding a shared node may be generated such that it extracts, from within the kernel pattern, (1) a combination of two general node variables and an edge connecting them, (2) a combination of a general node variable, a direct-designated node, and an edge connecting them, (3) a combination of a general node variable, a literal node, and an edge connecting them, (4) a combination of two direct-designated nodes and an edge connecting them, and (5) a combination of a direct-designated node, a literal node, and an edge connecting them, and finds any node satisfying these conditions.

Thereafter, in step 735, the query generated in step 730 is transmitted to the graph repository 275, and on the basis of the returned information about the shared node, an entry corresponding to the shared node is added to the DBT generated in step 720. The process then proceeds to step 740, where the process is terminated. At this point in time, the DBT has been formed in which entries for only the representative node and the shared node (if any) are filled, while entries for the remaining nodes are empty.

With reference to a flowchart 630 in FIG. 8, an example of the DBT processing corresponding to the object updating manipulation (UPDATE) in the object data, performed in step 630 in FIG. 6, will be described in more detail. FIG. 8 shows the flowchart illustrating an operation of the DBT processing corresponding to the object updating manipulation (UPDATE), performed by the data processing system of the embodiment of the present invention. The process starts at step 805. In step 810, the DBT corresponding to the object as a target of the updating manipulation (UPDATE) read in step 615 is specified.

Then, in step 815, in accordance with the content of the updating manipulation (UPDATE) read in step 615, the entry in the DBT specified in step 810 is updated. The process proceeds to step 820, where an update mark is applied to the entry updated in step 815, and the process is terminated in step 825.

With reference to a flowchart 635 in FIG. 9, an example of the DBT processing corresponding to the object deleting manipulation (DELETE) in the object data, performed in step 635 in FIG. 6, will be described in more detail. FIG. 9 shows the flowchart illustrating an operation of the DBT processing corresponding to the object deleting manipulation (DELETE), performed by the data processing system of the embodiment of the present invention. The process starts at step 905. In step 910, the DBT corresponding to the object as a target of the deleting manipulation (DELETE) read in step 615 is specified. Next, in step 915, a delete mark is applied to the DBT specified in step 910, and the process is terminated in step 920.

Next, with reference to a flowchart 645 in FIG. 10, an example of the processing of modifying the graph data in the graph repository on the basis of the DBT, performed in step 645 in FIG. 6, will be described in more detail. FIG. 10 shows the flowchart illustrating an operation of the graph data modification processing by the data processing system of the embodiment of the present invention. The process starts at step 1005. In step 1010, a kernel pattern corresponding to the object as a target of the manipulation read in step 615 is specified.

The process proceeds to step 1015, where it is determined whether a delete mark has been applied to the DBT corresponding to the object as a target of the manipulation read in step 615. If it is determined in step 1015 that a delete mark has been applied to the DBT, the process follows the YES arrow to proceed to step 1020.

In step 1020, the kernel pattern specified in step 1010 is used to specify any node that is not a shared node, from among the nodes in the graph data that are included in the object as the target of manipulation. More specifically, a query for finding a shared node, as described above in conjunction with step 730, may be generated and transmitted to the graph repository 275 to specify the shared node, and the specified shared node may be excluded from the nodes in the graph data that are included in the object as the target of manipulation.

Then, in step 1025, one node is extracted from a set of the non-shared nodes specified in step 1020. The process then proceeds to step 1030. In step 1030, any node and/or edge in the graph data that is associated with the node extracted in step 1025 is deleted by running a query on the graph repository. In step 1035, it is determined whether there still remains another node specified in step 1020. If so, the process follows the YES arrow to return to step 1025, to repeat the similar processing. If it is determined that there remains no node, the process follows the NO arrow to proceed to step 1060, where the process is terminated.

If it is determined in step 1015 that the delete mark is not applied to the DBT, the process follows the NO arrow to proceed to step 1040. In step 1040, any entry having the update mark applied thereto in the DBT corresponding to the object as the target of the manipulation read in step 615 is specified.

Next, in step 1045, one entry is extracted from a set of the entries having the update mark applied thereto specified in step 1040. The process then proceeds to step 1050. In step 1050, in accordance with the content of the entry extracted in step 1045, the node and/or edge in the graph data in the graph repository is updated. In step 1055, it is determined whether there still remains another entry specified in step 1040. If so, the process follows the YES arrow to return to step 1045, to repeat the similar processing. If it is determined that there remains no entry, the process follows the NO arrow to proceed to step 1060, where the process is terminated.

The object data manipulating processing and the processing of reflecting the result in the graph data in the graph repository have been described above. The object manipulation and the accompanying DBT processing will be described below by giving two examples.

FIG. 19 shows a first example of the flow of the object manipulation. In the first example, in the object data shown in FIG. 18, a new object 1905 (“Member”) is generated (CREATE); then, an attribute value “Yamada” is input to the generated object 1905 (UPDATE); and then, a relation 1915 is added between the object 1810 and the object 1905 (UPDATE).

FIG. 20 shows manipulation logs for the first example of the flow of the object manipulation. The above-described object generating manipulation, attribute value inputting manipulation, and relation adding manipulation are logged as manipulation logs 2005, 2010, and 2015, respectively.

FIG. 21 shows DBTs that change in accordance with the first example of the flow of the object manipulation. First, the manipulation log 2005 corresponding to the generation of the object 1905 is read to perform the DBT processing. As a result, a DBT 2105 is generated that includes only the entries for the representative node variable (“$A”) and the general node variable (“?S1”). Next, the manipulation log 2010 corresponding to the input of the attribute value “Yamada” is read to perform the DBT processing. As a result, the entry for the unique node “#N” in the DBT 2105 is updated. Then, on the basis of the DBT 2105 having all the entries filled, the graph data in the graph repository 275 is modified.

Next, the manipulation log 2015 corresponding to the addition of the relation 1915 is read to perform the DBT processing. As a result, information 2110 on the relation 1915 is added to the entry for the interlink “members” in the DBT 1530. Then, on the basis of the DBT 1530, the graph data in the graph repository 275 is modified. The graph data in the graph repository 275 as a result of the above modifications is shown in FIG. 22.

FIG. 23 shows a second example of the flow of the object manipulation. In the second example, in the object data shown in FIG. 19 that has undergone the manipulations in the first example, the attribute value of the existing object 2305 is changed from “Suzuki” to “Suzuta” (UPDATE); then, the relation 1915 is deleted (UPDATE); and then, the object 1905 is deleted (DELETE).

FIG. 24 shows manipulation logs for the second example of the flow of the object manipulation. The above-described object attribute value changing manipulation, relation deleting manipulation, and object deleting manipulation are logged as manipulation logs 2405, 2410, and 2415, respectively.

FIG. 25 shows DBTs that change in accordance with the second example of the flow of the object manipulation. First, the manipulation log 2405 corresponding to the change of the attribute value of the object 2305 is read to perform the DBT processing, so that the attribute value 2515 in the DBT 1525 is changed. Then, on the basis of the DBT 1525, the graph data in the graph repository 275 is modified.

Next, the manipulation log 2410 corresponding to the deletion of the relation 1915 is read to perform the DBT processing, so that the information 2110 corresponding to the relation 1915 is deleted from the entry for the interlink “members” in the DBT 1530. Then, on the basis of the DBT 1530, the graph data in the graph repository 275 is modified. Further, the manipulation log 2415 corresponding to the deletion of the object 1905 is read to perform the DBT processing, so that the delete mark 2510 is applied to the DBT 2105. Then, on the basis of the DBT 2105 having the delete mark 2510 applied thereto, the graph data in the graph repository 275 is modified. The graph data in the graph repository 275 as a result of the above modifications is shown in FIG. 26.

FIG. 27 shows, by way of example, the hardware configuration of an information processing device which is suitable for implementing the terminals 100 and 105 and the server 110 according to the embodiment of the present invention. The information processing device includes a central processing unit (CPU) 1 and a main memory 4 each connected to a bus 2. Further, hard disk drives 13 and 30 and removable storages (external storage systems with removable recording media), such as CD-ROM drives 26 and 29, a flexible disk drive 20, an MO drive 28, and a DVD drive 31, are connected to the bus 2 via a flexible disk controller 19, an IDE controller 25, an SCSI controller 27, and so on.

Storage media such as a flexible disk, an MO, a CD-ROM, and a DVD-ROM are inserted into the removable storages. These storage media, the hard disk drives 13 and 30, and a ROM 14 may record codes of a computer program that cooperates with an operation system to provide the CPU and so on with instructions so as to implement the present invention. The computer program is executed as it is loaded to the main memory 4. The computer program may be compressed or divided into a plurality of parts so as to be recorded on a plurality of media.

The information processing device receives an input from an input device such as a keyboard 6 or a mouse 7 via a keyboard/mouse controller 5. The information processing device is connected via a DAC/LCDC 10 to a display device 11 for providing a user with visual data.

The information processing device may be connected to a network via a network adapter 18 (Ethernet (R) card, token-ring card) or the like for communication with other computers. Although not shown in the figure, the information processing device may also be connected to a printer via a parallel port, or to a modem via a serial port.

It will readily be appreciated from the above description that the information processing device suitable for implementing the data processing system according to the embodiment of the present invention may be implemented by an information processing device such as a typical personal computer, work station, mainframe, or a combination thereof. The constituent elements, however, are only illustrative; not all the elements are indispensable for the present invention.

Various modifications, including combining a plurality of machines so as to distribute thereto the functions of the hardware components of the information processing device used in the embodiment of the present invention, will of course be readily conceivable for those skilled in the art. Such modifications are naturally within the scope of the present invention.

The data processing system of the embodiment of the present invention adopts an operating system that supports a graphical user interface (GUI) multi-window environment, such as the Windows (R) operating system provided by Microsoft Corporation, MacOS (R) provided by Apple Computer Incorporated, and a UNIX (R) like system equipped with the X Window System (for example, AIX (R) provided by International Business Machines Corporation).

From the above description, it can be understood that the data processing system used in the embodiment of the present invention is not restricted to any particular multi-window operating system environment.

As described above, according to the embodiment of the present invention, an efficient system, software, and method for converting graph data to a data structure that enables manipulations performed in various applications to be reflected in the original graph data are implemented. This can enhance the user productivity of operating an object handling system to manipulate the object data to thereby edit the graph data stored in a graph repository, as is readily understood.

Further, the present invention may be implemented as hardware, software, or a combination thereof. The combination of the hardware and software may be implemented typically in a data processing system having a predetermined program. In this case, the predetermined program may be loaded to the data processing system for execution, so that the program controls the data processing system to carry out the processing according to the present invention. This program is composed of a set of instructions that can be expressed in arbitrary language, code, or description. Such a set of instructions enables the system to carry out the specific functions directly, or after execution of one or both of:

(1) conversion to another language, code, or description; and (2) duplication to another medium.

Of course, not only such a program itself but also a medium recording the program are within the scope of the present invention. The program for executing the functions of the present invention may be stored in any computer-readable recording medium such as a flexible disk, MO, CD-ROM, DVD, hard disk drive, ROM, MRAM, RAM, and so on. The program may be downloaded from another data processing system connected via a communication line for storage in a recording medium, or may be duplicated from another recording medium. Further, the program may be compressed or divided into a plurality of parts so as to be stored in one or more recording media. It should also be noted that a program product for implementing the present invention may of course be provided in various manners.

It is apparent to those skilled in the art that various modifications or improvements are possible for the above-described embodiment. Such modified or improved embodiments, for example, are naturally within the technical scope of the present invention. 

The invention claimed is:
 1. A method for converting at least a part of graph data including nodes and edges to a data structure as an image of a homomorphism thereof by using at least one kernel pattern for graph matching, the method comprising the steps of: providing a kernel pattern including one representative node variable, the representative node variable having a first constraint that at most one node in the graph data matches the representative node variable and the node is prohibited from matching a node variable in another kernel pattern, wherein the kernel pattern includes at least one node variable of a second type and has a second constraint that a node in the graph data matching the second-type node variable has to uniquely correspond to the node in the graph data matching the representative node variable in the kernel pattern; performing matching between the graph data and the kernel pattern to obtain a matching result that does not violate constraints including the first constraint; and generating a data structure corresponding to the matching result that does not violate the constraints.
 2. The method according to claim 1, wherein the step of performing matching includes steps of obtaining, as the matching result, information on a subset of the graph data that matches the kernel pattern, and removing, from the matching result, information on any subset of the graph data that violates the constraints.
 3. The method according to claim 2, wherein the information on the subset of the graph data is a table including an entry of correspondence between a node variable included in the kernel pattern and the matching node in the graph data.
 4. The method according to claim 3, wherein the step of removing information from the matching result includes a step of removing the table corresponding to the subset of the graph data that violates the constraints.
 5. The method according to claim 1, wherein a node matching the representative node variable may become an endpoint of an interlink with a node belonging to another kernel pattern.
 6. The method according to claim 1, wherein in the case where a plurality of kernel patterns the representative node variables of which matched a came node in the graph data in the step of performing matching have an inheritance relationship with each other, a data structure corresponding to the matching result for the kernel pattern on the inheriting side is generated.
 7. The method according to claim 1, wherein a data structure corresponding to the matching result that violates neither the first constraint nor the second constraint is generated.
 8. The method according to claim 7, wherein a node matching the second-type node variable may become an endpoint of an interlink with a node belonging to another kernel pattern.
 9. The method according to claim 1, wherein the step of performing matching includes a step of running a graph query corresponding to the kernel pattern on the graph data.
 10. The method according to claim 1, wherein the step of performing matching includes a step of performing matching of an interlink, the interlink connecting nodes belonging to different kernel patterns.
 11. The method according to claim 10, wherein the step of performing matching includes a step of removing the matching result for any interlink that is inconsistent with the matching result for the node variable.
 12. The method according to claim 10, wherein the step of performing matching includes a step of merging the matching result for the interlink into the matching result for the node variable.
 13. The method according to claim 1, wherein the step of generating a data structure includes a step of generating a data structure by instantiating a class definition of a data structure corresponding to the kernel pattern.
 14. The method according to claim 1, further comprising the step of passing the generated data structure to an application for presentation to a user.
 15. A method for converting at least a part of graph data including nodes and edges to a data structure as an image of a homomorphism thereof by using at least one kernel pattern for graph matching, the method comprising the steps of: providing a kernel pattern including one representative node variable, the representative node variable having a first constraint that at most one node in the graph data matches the representative node variable and the node is prohibited from matching a node variable in another kernel pattern, wherein the kernel pattern includes at least one node variable of a second type and has a second constraint that a node in the graph data matching the second-type node variable has to uniquely correspond to the node in the graph data matching the representative node variable in the kernel pattern; performing matching between the graph data and the kernel pattern to obtain a matching result that does not violate constraints including the first constraint, wherein the step of performing matching includes the steps of: obtaining, as the matching result, information on a subset of the graph data that matches the kernel pattern; and removing, from the matching result information on any subset of the graph data that violates the constraints; and generating a data structure corresponding to the matching result that does not violate the constraints.
 16. A computer readable program stored on a non transitory computer-readable storage medium for converting at least a part of graph data including nodes and edges to a data structure as an image of a homomorphism thereof by using at least one kernel pattern for graph matching, wherein the computer readable program when executed on a computer causes the computer to perform the steps of: providing a kernel pattern including one representative node variable, the representative node variable having a first constraint that at most one node in the graph data matches the representative node variable and the node is prohibited from matching a node variable in another kernel pattern, wherein the kernel pattern includes at least one node variable of a second type and has a second constraint that a node in the graph data matching the second-type node variable has to uniquely correspond to the node in the graph data matching the representative node variable in the kernel pattern; performing matching between the graph data and the kernel pattern to obtain a matching result that does not violate constraints including the first constraint; and generating a data structure corresponding to the matching result that does not violate the constraints.
 17. The computer readable program of claim 16, wherein the step of performing matching includes steps of obtaining, as the matching result, information on a subset of the graph data that matches the kernel pattern, and removing, from the matching result, information on any subset of the graph data that violates the constraints.
 18. The computer readable program of claim 16, wherein in the case where a plurality of kernel patterns the representative node variables of which matched a same node in the graph data in the step of performing matching have an inheritance relationship with each other, a data structure corresponding to the matching result for the kernel pattern on the inheriting side is generated.
 19. The computer readable program of claim 16, wherein A data structure corresponding to the matching result that violates neither the first constraint nor the second constraint is generated.
 20. The computer readable program of claim 16, wherein the step of performing matching includes a step of running a graph query corresponding to the kernel pattern on the graph data. 